77 research outputs found
The Constructive method for query containment checking (extended version)
We present a new method that checks Query Containment for queries with negated derived atoms and/or integrity constraints.
Existing methods for Query Containment checking that deal with these cases do not check actually containment but another
related property called uniform containment, which is a sufficient but not necessary condition for containment. Our method can
be seen as an extension of the canonical databases approach beyond the class of conjunctive queries.Postprint (published version
A common framework for classifying and specifying deductive database updating problems
Several problems may arise when updating a deductive database. Up to now,
the general approach of the research related to deductive database updating problems
has been to provide specific methods for solving particular problems. However, ali
these methods are explicitly or implicitly based on a set of rules that define the
changes that occur in a transition from an old state of a database to a new, updated
state. Therefore, these rules provide the basis of a framework for classifying and
specifying these problems.
In this paper we propose to use the event rules [Oli91], which explicitly define
the insertions and deletions induced by an update, for such a basis. We also define
two interpretations of these rules which provide a common framework for
classifying and specifying deductive database updating problems such as view
updating, materialized view maintenance, integrity constraints checking, integrity
constraints maintenance, repairing inconsistent databases, integrity constraints
satisfiability or condition monitoring. Moreover, these interpretations allow us to
identify and to specify sorne problems that have received little attention up to now
like enforcing or preventing condition activation. By considering only a uniqu~ set
of rules for specifying all these problems, we want to show that it is possible to
provide general methods able to deal with all these problems as a whole
A schema-only approach to validate XML schema mappings
Since the emergence of the Web, the ability to map XML data between different data sources has become crucial. Defining a mapping is
however not a fully automatic process. The designer needs to figure out whether the mapping is what was intended. Our approach to this
validation consists of defining and checking certain desirable properties of mappings. We translate the XML schemas and the mapping into
first-order logic formalism and apply a reasoning mechanism to check the desirable properties automatically, without assuming any
particular instantiation of the schemas.Preprin
Validation of schema mappings with nested queries
With the emergence of the Web and the wide use of XML for representing data, the ability to map not only flat relational but also nested data has become crucial. The design of schema mappings is a semi-automatic process. A human designer is needed to guide the process, choose among mapping candidates, and successively refine the mapping. The designer needs a way to figure out whether the mapping is what was intended. Our approach to mapping validation allows the designer to check whether the mapping satisfies certain desirable properties. In this paper, we focus on the validation of mappings between nested relational schemas, in which the mapping assertions are either inclusions or equalities of nested queries. We focus on the nested relational setting since most XML’s Document Type Definitions (DTDs) can be represented in this model. We perform the validation by reasoning on the schemas and mapping definition. We take into account the integrity constraints defined on both the source and target schema.Preprin
Query containment checking as a view updating problem
In this paper we present a new approach that handles query
containment problems by expressing them as a view updating
problem. Since this approach is independent of any particular view
updating method, it provides a general framework that joins research
efforts in both the query containment checking and view updating
fields. In particular, the larger development of current view updating
technology allows us to check properly query containment when
considering negative-derived literals or integrity
constraints. Existing methods for query containment checking that deal
with these cases do not check actually containment but another related
property called uniform containment, which is a sufficient but not
necessary condition for containment. Therefore, an important outcome
of our proposal is that, to the best of our knowledge, it is the first
approach that checks true query containment instead of uniform
query containment in the presence of negation and integrity
constraints.Postprint (published version
Testing Termination of Query Satisfiability Checking on Expressive Database Schemas
A query is satisfiable if there is at least one consistent instance of the database in which it has a non-empty answer. Defining queries on a database schema and checking their satisfiability can help the database designer to be sure whether the produced database schema is what was intended. The formulation of such queries may easily require the use of some arithmetic comparisons or negated expressions. Unfortunately, checking the satisfiability of this class of queries on a database schema that most likely have some
integrity constraints (e.g., keys, foreign keys, Boolean checks) is, in general, undecidable.
However, although the problem is undecidable for such a class of schemas and queries, it
may not be so for a particular query satisfiability check. In this paper, we propose to perform a termination test as a previous step to query satisfiability checking. If positive, the termination test guarantees that the corresponding query satisfiability check will terminate. We assume the CQC method is the underlying query satisfiability checking method; to the best of our knowledge, it is the only method of this kind able to deal with schemas and queries as expressive as the ones we consider.Preprin
AuRUS: explaining the validation of UML/OCL conceptual schemas
The validation and the verification of conceptual schemas have attracted a lot of interest during the last years, and several tools have been developed to automate this process as much as possible. This is achieved, in general, by assessing whether the schema satisfies different kinds of desirable properties which ensure that the schema is correct. In this paper we describe AuRUS, a tool we have developed to analyze UML/OCL conceptual schemas and to explain their (in)correctness. When a property is satisfied, AuRUS provides a sample instantiation of the schema showing a particular situation where the property holds. When it is not, AuRUS provides an explanation for such unsatisfiability, i.e., a set of integrity constraints which is in contradiction with the property.Peer ReviewedPostprint (author’s final draft
Computing explanations for unlively queries in databases
A query is lively in a database schema if it returns a non-empty answer for some database satisfying the schema. Debugging a database schema requires not only determining queries (as well as views or tables) that are not lively, but also fixing them. To make that task easier it is required to provide the designer with some explanation of why a query is not lively. To the best of our knowledge, the existing methods for liveliness checking in databases do not provide such explanations. An explanation is understood as the minimal set of constraints that are responsible for the non-liveliness of the tested query. In this paper we propose a method for computing such explanations which is independent of the particular method used to determine liveliness of a given query. Our method provides three levels of search: one explanation, a maximal set of non-overlapping explanations, and all explanations. The first two levels require only a linear number of callings to the underlying method. In addition, we propose a filter to reduce the number of callings to the underlying liveliness method. We also experimentally compare our method with a more naive method for query liveliness and with the best known method for finding unsatisfiable subsets of constraints.Postprint (published version
- …